home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / raytrace / radiance / simplerd.lha / simplerad / FinalFTP / Light / polyf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-17  |  32.2 KB  |  1,007 lines
  1. /**********************************************************************/
  2. /* poly.c                                                             */
  3. /*                                                                    */
  4. /* Read in polygons from and input file of format:                    */
  5. /*                                                                    */
  6. /* Number objects <number-objects>                                    */
  7. /* Object <object-id> (object-type) {                                 */
  8. /*     OWMatrix <matrix-id> { (matrix) }                              */
  9. /*     prop <property-id> { E{ vec } p{ vec } Kd{ val } Ks{ val }     */
  10. /*     NumMeshes <number-of-meshes>                                   */
  11. /*     (possible-mesh)                                                */
  12. /*                                                                    */
  13. /*  OWMatrix identifies an object to world matrix,                    */
  14. /*  prop identifies an object property, E is the emittance,           */
  15. /*  p is the reflectance, Kd = diffuse component, and Ks the specular */
  16. /*                                                                    */
  17. /* where:                                                             */
  18. /*  object-type = mesh, cube, cone, cylinder, or sphere               */
  19. /*  matrix = { vec } { vec } { vec } { vec }                          */
  20. /*  vec = val val val                                                 */
  21. /*  val = floating point value                                        */
  22. /*  possible-mesh = if (object-type == mesh) { read-mesh-in-place }   */
  23. /*                  else { mesh-read-from-file }                      */
  24. /*  mesh = Mesh <mesh-id> <number-polygons> {                         */
  25. /*            Patch vert<vertex#> <num-vertices> { vertices }         */
  26. /*            Patch norm<norm#>   <num-normals>  { normals }          */
  27. /*  vertices = { vec } { vec } ...                                    */
  28. /*  normals  = { vec } { vec } ...                                    */
  29. /*                                                                    */
  30. /**********************************************************************/
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <string.h>
  34. #include <math.h>
  35. #include "misc.h"
  36. #include "geo.h"
  37. #include "struct.h"
  38. #include "io.h"
  39. #include "poly.h"
  40. #include "rad.h"
  41. #include "adj.h"
  42. #include "bvol.h"
  43. #include "ff.h"
  44. #include "rtime.h"
  45.  
  46. #define ENLARGE_BOX   (0.000)         /* Amount to enlarge obj BV by */
  47. #define ENLARGE_WORLD (0.6)           /* Amount to enlarge world BV by */
  48.  
  49. extern Time_Stats tstats;
  50. extern double MIN_ELEMENT_PERC;
  51. extern HBBox Scene_BVH;
  52. extern Vertex_list *vlist;
  53. extern unsigned long vlist_size;
  54. extern Vertex_tree *vtree;
  55. extern unsigned long vtree_size;
  56. extern FF_OptionType FF_Options;
  57. extern BoundingBoxType BoxCone();
  58. extern BoundingBoxType BoxCube();
  59. extern BoundingBoxType BoxCylinder();
  60. extern BoundingBoxType BoxSphere();
  61. extern void SetOptions();
  62. extern void LogStats();
  63. extern void LogRlog();
  64. extern void Create_Initial_ReceiverList();
  65.  
  66. #ifdef IRIS4D
  67. extern void InitRad();
  68. extern void DoRad();
  69. extern void CleanUpRad();
  70. #endif /* IRIS4D */
  71.  
  72. /**********************************************************************/
  73. /* Structures for reading scene */
  74. /**********************************************************************/
  75. char *tmp = "                   ";
  76. char *tmp2 = "                  ";
  77. float tmpf[9];             /* For floating pt reading only ! */
  78. int premesh = 0;
  79.  
  80. RadParams ReadLog;         /* Radiosity parameters */
  81. Scene RadScene;            /* Scene to do radiosity on */
  82.  
  83. /**********************************************************************/
  84. void Read_Prim_Mesh();
  85. void Read_Mesh();
  86. void Read_Polygon();
  87. void Read_MToW();
  88. void Read_Surface_Properties();
  89. void GetMeshFromFile();
  90. int Read_Objects();
  91. void Read_Scene();
  92. void Print_InitialStats();
  93.  
  94. /*====================================================================*/
  95. /* Polygon setup  routines */
  96. /*====================================================================*/
  97. /**********************************************************************/
  98. /* Get d paramater of plane for a polgyon */
  99. /**********************************************************************/
  100. double Poly_PlaneD(poly_normal, poly_point)
  101.      Vector poly_normal, poly_point;
  102. {
  103.   return(-dot(&poly_normal, &poly_point));
  104. }
  105.  
  106. /**********************************************************************/
  107. /* Get area of a n-sided polygon using Stoke's Theorem */
  108. /**********************************************************************/
  109. double Poly_Area(v, norm, num_vert)
  110.      Vector v[MAX_PATCH_VTX];
  111.      Vector norm;
  112.      int num_vert;
  113. {
  114.   double area;
  115.   Vector v_cross_v1;
  116.   int i;
  117.   double sum_v;
  118.  
  119.   sum_v = 0.0;
  120.   for (i=0;i<num_vert;i++) {
  121.     v_cross_v1 = cross(&v[i],&v[(i+1) % num_vert]);
  122.     sum_v += dot(&norm, &v_cross_v1);
  123.   }
  124.   area = 0.5 * _ABS(sum_v);
  125.   if (area <= DAMN_SMALL)
  126.     printf("Hey the area is really small.\n");
  127.   if (area == 0.0) {
  128.     printf("Hey the area is too small.\n");
  129.     exit(1);
  130.   }
  131.   return area;
  132. }
  133.  
  134. /**********************************************************************/
  135. /* Find U, V, W planes formed by edges of quad or triangle            */
  136. /**********************************************************************/
  137. void Poly_UVW(pptr)
  138.      Polygon *pptr;
  139. {
  140.   int i;
  141.   Vector u,v,w;
  142.   Vector corner[MAX_PATCH_VTX];
  143.   polyUVW *uvw;
  144.  
  145.   uvw = (polyUVW *) malloc(sizeof(polyUVW));
  146.  
  147.   for (i=0;i<pptr->numVert;i++)
  148.     corner[i] = pptr->vert[i]->pos;
  149.  
  150.   if (pptr->class == PATCH) {
  151.     u = *vsub(&corner[1], &corner[0]);
  152.     uvw->Lu = vlen(&u);
  153.     norm(&u);
  154.     uvw->Nu = cross(&pptr->normal[0], &u);
  155.     uvw->du = Poly_PlaneD(uvw->Nu, corner[1]);
  156.     
  157.     v = *vsub(&corner[3], &corner[0]);
  158.     uvw->Lv = vlen(&v);
  159.     norm(&v);
  160.     uvw->Nv = cross(&v, &pptr->normal[0]);
  161.     uvw->dv = Poly_PlaneD(uvw->Nv, corner[3]);
  162.  
  163.   } else if (pptr->class == TRIANGLE) {
  164.     u = *vsub(&corner[1], &corner[0]);
  165.     uvw->Lu = vlen(&u);
  166.     norm(&u);
  167.     uvw->Nu = cross(&pptr->normal[0], &u);
  168.     uvw->du = Poly_PlaneD(uvw->Nu, corner[1]);
  169.  
  170.     v = *vsub(&corner[2], &corner[1]);
  171.     uvw->Lv = vlen(&v);
  172.     norm(&v);
  173.     uvw->Nv = cross(&pptr->normal[0], &v);
  174.     uvw->dv = Poly_PlaneD(uvw->Nv, corner[2]);
  175.  
  176.     w = *vsub(&corner[0], &corner[2]);
  177.     uvw->Lw = vlen(&w);
  178.     norm(&w);
  179.     uvw->Nw = cross(&pptr->normal[0], &w);
  180.     uvw->dw = Poly_PlaneD(uvw->Nw, corner[0]);
  181.  
  182.   } else {
  183.     fprintf(stderr, "Polygon type not supported. Can't calculate UVW.\n");
  184.     exit(1);
  185.   }
  186.   pptr->uvw = uvw;
  187. }
  188.  
  189.  
  190. /*====================================================================*/
  191. /* Scene reading routines */
  192. /*====================================================================*/
  193.  
  194. /**********************************************************************/
  195. /* Initialize size of world */
  196. /**********************************************************************/
  197. void Init_WorldSize(rlog)
  198.      RadParams *rlog;
  199. {
  200.   rlog->worldbox.min.x = VERY_LARGE / 2.0;
  201.   rlog->worldbox.min.y = VERY_LARGE / 2.0;
  202.   rlog->worldbox.min.z = VERY_LARGE / 2.0;
  203.   rlog->worldbox.max.x = -VERY_LARGE / 2.0;
  204.   rlog->worldbox.max.y = -VERY_LARGE / 2.0;
  205.   rlog->worldbox.max.z = -VERY_LARGE / 2.0;
  206.   rlog->worldSize = VERY_LARGE / 2.0;
  207. }
  208.  
  209. /**********************************************************************/
  210. /* Find minumum bounding box size for the world */
  211. /**********************************************************************/
  212. void Update_WorldSize(pt)
  213.      Vector pt;
  214. {
  215.   if (pt.x > ReadLog.worldbox.max.x)  ReadLog.worldbox.max.x = pt.x;
  216.   if (pt.y > ReadLog.worldbox.max.y)  ReadLog.worldbox.max.y = pt.y;
  217.   if (pt.z > ReadLog.worldbox.max.z)  ReadLog.worldbox.max.z = pt.z;
  218.  
  219.   if (pt.x < ReadLog.worldbox.min.x)  ReadLog.worldbox.min.x = pt.x;
  220.   if (pt.y < ReadLog.worldbox.min.y)  ReadLog.worldbox.min.y = pt.y;
  221.   if (pt.z < ReadLog.worldbox.min.z)  ReadLog.worldbox.min.z = pt.z;
  222. }
  223.  
  224. /**********************************************************************/
  225. /* Make bounding sphere and bounding box of world */
  226. /**********************************************************************/
  227. void BoxWorld(rlog)
  228.      RadParams *rlog;
  229. {
  230.   if (rlog->worldbox.min.x > rlog->worldbox.max.x) {
  231.     printf("Oh oh. the world min is greater than the max!\n");
  232.     exit(1);
  233.   }
  234.   rlog->worldbox.min.x -= ENLARGE_WORLD;
  235.   rlog->worldbox.min.y -= ENLARGE_WORLD;
  236.   rlog->worldbox.min.z -= ENLARGE_WORLD;
  237.   rlog->worldbox.max.x += ENLARGE_WORLD;
  238.   rlog->worldbox.max.y += ENLARGE_WORLD;
  239.   rlog->worldbox.max.z += ENLARGE_WORLD;
  240.  
  241.   rlog->worldSize = 0.5 * (vdist(&(rlog->worldbox.max), 
  242.                  &(rlog->worldbox.min)) + 0.5);
  243. }
  244.  
  245. /**********************************************************************/
  246. /* Make bounding sphere and bounding box of world */
  247. /**********************************************************************/
  248. void Enlarge_BoxSize(box)
  249.      BoundingBoxType *box;
  250. {
  251.   box->min.x -= ENLARGE_BOX;
  252.   box->min.y -= ENLARGE_BOX;
  253.   box->min.z -= ENLARGE_BOX;
  254.   box->max.x += ENLARGE_BOX;
  255.   box->max.y += ENLARGE_BOX;
  256.   box->max.z += ENLARGE_BOX;
  257. }
  258.  
  259. /**********************************************************************/
  260. /**********************************************************************/
  261. void Presub_Polygon(pptr, level)
  262.      Polygon *pptr;
  263.      int level;
  264. {
  265.   int i;
  266.  
  267.   /* printf("At level %d\n", level); */
  268.   if (level <= 0) return;
  269.   else {
  270.     Subdivide_Polygon(pptr);
  271.     level--;
  272.     for (i=0;i<MAX_PATCH_CHILDREN;i++) 
  273.       Presub_Polygon(pptr->child[i], level);
  274.   }
  275. }
  276.  
  277. /**********************************************************************/
  278. /* Read in polygon info */
  279. /**********************************************************************/
  280. void Read_Polygon(meshf, pptr, mptr, optr, origB)
  281.      FILE *meshf;
  282.      Polygon *pptr;
  283.      Mesh *mptr;
  284.      Objectt *optr;
  285.      Spectra origB;
  286. {
  287.   int i,j;
  288.   float tmpf[4];
  289.   char *tmp = "                    ";
  290.   Vector va[MAX_PATCH_VTX];
  291.   Vector v;
  292.  
  293.   /* Read in name and number of normals for the patch */
  294.   fscanf(meshf,"%s %d {",tmp , &(pptr->numVert));
  295.   pptr->id = ReadLog.totpoly++;
  296.   pptr->next = pptr+1;
  297.   if (Option.debug) printf("  Patch %s %d {", tmp, pptr->numVert);
  298.   
  299.   /* Set id, type, no children, tree level, mesh poly belongs to,
  300.    and poly, this poly belongs to */
  301.   if (pptr->numVert == 4) {
  302.     pptr->name = PATCH_ID;
  303.     pptr->class = PATCH;
  304.   } else if (pptr->numVert == 3) {
  305.     pptr->name = TRI_ID;
  306.     pptr->class = TRIANGLE;
  307.   } else {
  308.     fprintf(stderr, "Sorry, only quadtralaterals and triangles allowed\n");
  309.     exit(1);
  310.   }
  311.   for(i=0;i<MAX_PATCH_CHILDREN;i++)
  312.     pptr->child[i] = 0;               /* No children yet */
  313.   pptr->level = 0; pptr->Pfather = 0; /* is root of quad-tri tree */
  314.   pptr->Mfather = mptr;               /* mesh poly belongs to */
  315.   pptr->Links = (PolyList *)0;        /* No form factor links */
  316.   pptr->polyhead.front = pptr->polyhead.back = pptr->Links;
  317.   pptr->polyhead.num_polys = 0;
  318.     
  319.   /* Set total and unshot radiosity values for patch, and vertices */
  320.   for(i=0;i<MAX_SPECTRA_SAMPLES;i++) {
  321.     pptr->unshot_B.samples[i] = pptr->B.samples[i] = origB.samples[i];
  322.     for (j=0;j<pptr->numVert;j++)
  323.       pptr->vtx_B[j].samples[i] = origB.samples[i];
  324.   }
  325.   
  326.   /* Read normals of patch */
  327.   for (i=0;i<(pptr->numVert);i++) {
  328.     fscanf(meshf, " { %g %g %g }", &tmpf[0], &tmpf[1], &tmpf[2]);
  329.     pptr->normal[i].x = tmpf[0];
  330.     pptr->normal[i].y = tmpf[1];
  331.     pptr->normal[i].z = tmpf[2];
  332.     norm(&(pptr->normal[i]));
  333.  
  334.     /* Rotate normals if needed into world space */
  335.     if (same_matrix3x3(optr->MToW, Identity) == 0) {
  336.       pptr->normal[i] = vrotate(pptr->normal[i], optr->MToW);
  337.       norm(&(pptr->normal[i]));
  338.     }
  339.     
  340.     if (Option.debug)
  341.       printf(" { %g %g %g }", (pptr->normal[i].x),
  342.          (pptr->normal[i].y),(pptr->normal[i].z));
  343.   }
  344.   fscanf(meshf," }\n"); /* End normal read */
  345.   if (Option.debug) printf(" }\n");
  346.  
  347.   /* Read in size = number of vertices of patch */
  348.   fscanf(meshf, "Patch %s %d {", tmp, &(pptr->numVert));
  349.   if (Option.debug) printf("  Patch %s %d {", tmp, pptr->numVert);
  350.  
  351.   /* Read vertices of patch */
  352.   for (i=0;i<(pptr->numVert);i++) {
  353.     fscanf(meshf, " { %g %g %g }", &tmpf[0], &tmpf[1], &tmpf[2]);
  354.     v.x = tmpf[0]; 
  355.     v.y = tmpf[1]; 
  356.     v.z = tmpf[2];
  357.  
  358.     /* Transform vertex if needed into world space */
  359.     if (same_matrix(optr->MToW, Identity) == 0)
  360.       v = vtransform(v, optr->MToW);
  361.     if (Option.debug) printf(" {%g %g %g}", v.x, v.y, v.z);
  362.     va[i] = v;
  363.  
  364.     /* Update size of the world, and size of bounding box for mesh */
  365.     Update_WorldSize(v);
  366.     if (optr->num_meshes != -1)       /* Is not a primitive */
  367.       Update_BoxSize(v,optr->box);
  368.     if (optr->primid == MESH) 
  369.       Update_BoxSize(v,mptr->box);
  370.  
  371.     /* Form adjacency links between vertices and polygon */
  372.     if (vtree == 0) { /* Empty vertex tree */
  373.       pptr->vert[i] = Vertex_Create(v,pptr);
  374.       vtree = VTree_NodeCreate(pptr->vert[i],0); /* No father, is root */
  375.     } else {
  376.       VTree_NodeFind(v,vtree,pptr,i);
  377.     }
  378.   
  379.   }
  380.   fscanf(meshf," }\n"); /* End polygon vertex read */
  381.   if (Option.debug) printf(" }\n");
  382.  
  383.   /* Calculate area and d of plane where poly resides */  
  384.   pptr->d = Poly_PlaneD(pptr->normal[1], va[1]);
  385.   pptr->area = Poly_Area(va, pptr->normal[0], pptr->numVert);
  386.  
  387.   /* Calculate u,v,w planes of edges of poly */
  388.   Poly_UVW(pptr);
  389.   pptr->changingNormal = 0;
  390.  
  391.   /* Calculate total energy and total area in scene */
  392.   ReadLog.totalArea += pptr->area;
  393.   for(i=0;i<MAX_SPECTRA_SAMPLES;i++)
  394.     ReadLog.totalEnergy += origB.samples[i] * pptr->area;
  395.  
  396.   /* Pre-subdivide if specified */
  397.   if (premesh == 1) 
  398.     Subdivide_Polygon(pptr);
  399.   else if (premesh > 1) 
  400.     Presub_Polygon(pptr, premesh);
  401. }
  402.  
  403. /**********************************************************************/
  404. /* Read mesh info */
  405. /**********************************************************************/
  406. void Read_Mesh(meshf, optr)
  407.      FILE *meshf;
  408.      Objectt *optr;
  409. {
  410.   Mesh *mptr;
  411.   Polygon *pptr;
  412.   char *tmp = "                    ";
  413.  
  414.   if (Option.debug) printf("  NumMeshes %d\n", optr->num_meshes);
  415.   mptr = optr->meshes
  416.     = (Mesh *)malloc ((optr->num_meshes) *sizeof(Mesh));
  417.   ReadLog.meshcount = 0;
  418.  
  419.   /* Read in mesh information from current input file */
  420.   while ((fscanf(meshf,"    Mesh ") != -1) && 
  421.      (ReadLog.meshcount < optr->num_meshes)) {
  422.  
  423.     /* Allocate space for polygons in mesh */
  424.     fscanf(meshf, "%s %d {\n", tmp, &(mptr->num_polys));
  425.     mptr->id = ReadLog.totmesh++;
  426.     mptr->name = MESH_ID;
  427.     mptr->Ofather = optr;
  428.     pptr = mptr->polys
  429.       = (Polygon *)malloc ((mptr->num_polys) *sizeof(Polygon));
  430.  
  431.     /* Allocate space for mesh bounding box if object is 
  432.        a polygonal mesh */
  433.     if (optr->primid == MESH) {
  434.       mptr->box = (BoundingBoxType *) malloc(sizeof(BoundingBoxType));
  435.       BoxInit(mptr->box);
  436.     } else 
  437.       mptr->box = (BoundingBoxType *)0;
  438.  
  439.     if (Option.debug) printf("  Mesh %s %d {\n", tmp, mptr->num_polys);
  440.     
  441.     /* Read in polygon information for mesh */
  442.     ReadLog.polycount = 0;
  443.     while ((fscanf(meshf,"    Patch ") != -1) && 
  444.        (ReadLog.polycount < mptr->num_polys)) {
  445.       
  446.       Read_Polygon(meshf,pptr,mptr,optr,optr->surface->rad.E);
  447.       pptr++;
  448.       ReadLog.polycount++;
  449.     }
  450.     fscanf(meshf,"    }\n"); /* End mesh read */
  451.  
  452.     mptr++;
  453.     ReadLog.meshcount++;
  454.   }
  455. }
  456.  
  457. /**********************************************************************/
  458. /* Read object to world space matrix, and create inverse matrix */
  459. /**********************************************************************/
  460. void Read_MToW(meshf, optr)
  461.      FILE *meshf;
  462.      Objectt *optr;
  463. {
  464.   int i,j;
  465.  
  466.   /* Read in object to world matrix, and set world-object matrix */
  467.   fscanf(meshf,"OWMatrix %s { ", tmp);
  468.   copy_matrix(Identity, optr->MToW);
  469.   for (i=0; i<4; i++) for (j=0; j<3; j++) {
  470.     fscanf(meshf,"%g ", &tmpf[0]);
  471.     optr->MToW[i][j] = tmpf[0];
  472.   }
  473.   invert_matrix(optr->MToW,optr->WToM);
  474.   fscanf(meshf,"}\n"); /* End read matrix */
  475.           
  476.   if (Option.debug) {
  477.     printf("  OWMatrix %s {\n", tmp);
  478.     for(i=0;i<4;i++) {
  479.       printf("\t");
  480.       for(j=0;j<4;j++) printf("%g ", optr->MToW[i][j]);
  481.       printf("\n");
  482.     }
  483.   }
  484. }
  485.  
  486. /**********************************************************************/
  487. /* Allocate space and read in object surface properties */
  488. /**********************************************************************/
  489. void Read_Surface_Properties(meshf, optr)
  490.      FILE *meshf;
  491.      Objectt *optr;
  492. { 
  493.   SurfaceProp *sptr;
  494.   static int surfprop_id = 0;
  495.  
  496.   /* Allocate space for surface properties */
  497.   sptr = optr->surface = (SurfaceProp *)malloc(sizeof(SurfaceProp));    
  498.    
  499.   fscanf(meshf,
  500.      "    Prop %s { E{ %g %g %g } p{ %g %g %g } Kd{ %g } Ks{ %g } }\n",
  501.      tmp, &tmpf[0], &tmpf[1], &tmpf[2], &tmpf[3], &tmpf[4], &tmpf[5],
  502.      &tmpf[6], &tmpf[7]);
  503.   sptr->id = surfprop_id++;
  504.   sptr->name = tmp;
  505.   sptr->rad.E.samples[0] = tmpf[0];    /* Emittance */
  506.   sptr->rad.E.samples[1] = tmpf[1]; 
  507.   sptr->rad.E.samples[2] = tmpf[2];
  508.   sptr->shade.p.samples[0] = tmpf[3];  /* Reflectance */
  509.   sptr->shade.p.samples[1] = tmpf[4];
  510.   sptr->shade.p.samples[2] = tmpf[5];
  511.   sptr->shade.Kd.samples[0] = tmpf[6]; /* Diffuse & specular coefficients */
  512.   sptr->shade.Ks.samples[0] = tmpf[7];
  513.   sptr->rad.B.samples[0] = 0.0;        /* Radiance */
  514.   sptr->rad.B.samples[1] = 0.0;
  515.   sptr->rad.B.samples[2] = 0.0;
  516.  
  517.   if (Option.debug) 
  518.     printf("  Prop %s { E{ %g %g %g } p{ %g %g %g } Kd{ %g } Ks{ %g } }\n",
  519.        tmp, sptr->rad.E.samples[0],
  520.        sptr->rad.E.samples[1], sptr->rad.E.samples[2],
  521.        sptr->shade.p.samples[0], sptr->shade.p.samples[1], 
  522.        sptr->shade.p.samples[2], 
  523.        sptr->shade.Kd.samples[0], sptr->shade.Ks.samples[0]);
  524. }
  525.  
  526. /**********************************************************************/
  527. /* Read in mesh from primitive mesh file */
  528. /**********************************************************************/
  529. void Read_Prim_Mesh(filename, optr)
  530.      char *filename;
  531.      Objectt *optr;
  532. {
  533.   if (!(pmesh = fopen(filename, "r"))) {
  534.     fprintf(stderr,"%s: cannot read object file %s\n", ProgName, filename);
  535.     exit(1);
  536.   }
  537.  
  538.   fscanf(pmesh, "NumMeshes %d\n", &(optr->num_meshes));
  539.   ReadLog.polycount = 0;
  540.   Read_Mesh(pmesh, optr);
  541.   fclose(pmesh);
  542. }
  543.  
  544. /**********************************************************************/
  545. /* Read in scene from a input file */
  546. /**********************************************************************/
  547. void GetMeshFromFile(objtype, optr)
  548.      char *objtype;
  549.      Objectt *optr;
  550. {
  551.   BoundingBoxType obox;
  552.  
  553.   optr->primtype = objtype;
  554.  
  555.   /* Check if normals facing in or out */
  556.   if (optr->num_meshes == -2) 
  557.     optr->in_facingprim = TRUE;
  558.   else
  559.     optr->in_facingprim = FALSE;
  560.  
  561.   if (strcmp(objtype,"cone") == 0) {
  562.     obox = BoxCone();
  563.     optr->primid = CONE;
  564.     if (optr->num_meshes == -2) {
  565.       if (ReadLog.log) printf("\t*** cone(in) reading...\n");
  566.       Read_Prim_Mesh(iconefilename, optr);
  567.     } else {
  568.       if (ReadLog.log) printf("\t*** cone(out) reading...\n");
  569.       Read_Prim_Mesh(conefilename, optr);
  570.     }
  571.   } else if (strcmp(objtype,"cube") == 0) {
  572.     obox = BoxCube();
  573.     optr->primid = CUBE;
  574.     if (optr->num_meshes == -2) {
  575.       if (ReadLog.log) printf("\t*** cube(in) reading...\n");
  576.       Read_Prim_Mesh(icubefilename, optr);
  577.     } else {
  578.       if (ReadLog.log) printf("\t*** cube(out) reading...\n");
  579.       Read_Prim_Mesh(cubefilename, optr);
  580.     }
  581.   } else if (strcmp(objtype,"cylinder") == 0) {
  582.     obox = BoxCylinder();
  583.     optr->primid = CYLINDER;
  584.     if (optr->num_meshes == -2) {
  585.       if (ReadLog.log) printf("\t*** cylinder(in) reading...\n");
  586.       Read_Prim_Mesh(icylfilename, optr);
  587.     } else {
  588.       if (ReadLog.log) printf("\t*** cylinder(out) reading...\n");
  589.       Read_Prim_Mesh(cylfilename, optr);
  590.     }
  591.   } else if (strcmp(objtype,"sphere") == 0) {
  592.     obox = BoxSphere();
  593.     optr->primid = SPHERE;
  594.     if (optr->num_meshes == -2) {
  595.       if (ReadLog.log) printf("\t*** sphere(in) reading...\n");
  596.       Read_Prim_Mesh(isphfilename, optr);
  597.     } else {
  598.       if (ReadLog.log) printf("\t*** sphere(out) reading...\n");
  599.       Read_Prim_Mesh(sphfilename, optr);
  600.     }
  601.   } else {
  602.     printf("There's something wrong, primitive is invalid\n");
  603.     exit(0);
  604.   }
  605.   /* optr->num_meshes = -1; */
  606.  
  607.   /* Get transformed bounding box for object if tranformation 
  608.      not Identity */
  609.   if (same_matrix3x3(optr->MToW, Identity) == 0)
  610.     Bounds_Transform(optr->MToW, obox, optr->box);
  611.   Option.debug = 0;
  612. }
  613.  
  614. char *objmatch[5] = 
  615. { 
  616.   "precone", "precube", "precylinder", "premesh", "presphere" 
  617. };
  618. char *objreal[5] = 
  619. { 
  620.   "cone", "cube", "cylinder", "mesh", "sphere" 
  621.   };
  622. /**********************************************************************/
  623. /* Search string a for b, and return first number found               */
  624. /**********************************************************************/
  625. int Check_premesh(a, realtype)
  626.      char *a, **realtype;
  627. {
  628.   int match = 0;          /* Match found */
  629.   char level[2];          /* level to subdivide to */
  630.   int i;
  631.  
  632.   i=0;
  633.   while (i<5 && !match)   /* Scan for object type, return type */
  634.     if (strstr(a,objmatch[i])) {
  635.       match = 1;
  636.       *realtype = objreal[i];
  637.     }
  638.     else i++;
  639.  
  640.   if (match)              /* Scan for number of levels to mesh to */
  641.     for (i=0;i<9;i++) {
  642.       sprintf(level, "%d", i+1);
  643.       if (strstr(a, level))
  644.     match = i+1;
  645.     }
  646.   return(match);
  647. }
  648.  
  649. /**********************************************************************/
  650. /* Read in objects from file */
  651. /**********************************************************************/
  652. int Read_Objects(filename, obj)
  653.      char *filename;
  654.      Objectt **obj;     
  655. {
  656.   int nobjs = 0;                  /* Number of objects to read */
  657.   Objectt *optr;
  658.  
  659.   if (!(meshf = fopen(filename, "r"))) {
  660.     fprintf(stderr,"%s: cannot read object file %s\n", ProgName, filename);
  661.     exit(1);
  662.   }
  663.  
  664.   /* Find out # of objects and allocate space */
  665.   fscanf(meshf,"Number objects %d\n", &nobjs);
  666.   if (Option.debug) printf("Number objects %d\n", nobjs);
  667.   optr = *obj = (Objectt *)malloc (nobjs *sizeof(Objectt));
  668.  
  669.   /* Scan for objects (id, object type) */
  670.   ReadLog.objcount = 0;
  671.   while ((fscanf(meshf,"Object") != -1) && (ReadLog.objcount < nobjs)) {
  672.  
  673.     /* Set id, name, and primitive type */
  674.     fscanf(meshf, "%s %s {\n", tmp, tmp2);
  675.     optr->id = ReadLog.objcount;
  676.     optr->rayID = -1;
  677.     optr->name = "object"; 
  678.     optr->primtype = tmp2;
  679.  
  680.     if (premesh = Check_premesh(tmp2,&optr->primtype))
  681.       printf("\t    Tesselating %s (%d) to level %d\n", 
  682.          optr->primtype, optr->id, premesh);
  683.  
  684.     if (Option.debug)
  685.       printf("Object%d %s %s {\n", optr->id, optr->name, optr->primtype);
  686.  
  687.     /* Allocate space for object bounding volume */
  688.     optr->box = (BoundingBoxType *) malloc(sizeof(BoundingBoxType));
  689.  
  690.     /* Read model to world matrix */
  691.     Read_MToW(meshf, optr);
  692.  
  693.     /* Read surface properties */
  694.     Read_Surface_Properties(meshf, optr);
  695.       
  696.     /* Find out number of meshes in object */
  697.     fscanf(meshf, "    NumMeshes %d\n", &(optr->num_meshes));
  698.  
  699.     if ((optr->num_meshes) == -1 || (optr->num_meshes) == -2) {
  700.       /* Read in mesh info from primitive-mesh input files */
  701.       /* depending on type of object */
  702.       GetMeshFromFile(optr->primtype,optr); 
  703.  
  704.     } else {
  705.       /* Reading in mesh info from current input file */
  706.       if (ReadLog.log) printf("\t*** mesh reading...\n");
  707.       optr->primid = MESH;
  708.       BoxInit(optr->box);
  709.       Read_Mesh(meshf, optr);
  710.     }
  711.     fscanf(meshf,"}\n"); /* End object read */
  712.     if (Option.debug) printf("}\n");
  713.  
  714.     /* Enlarge box around object just a bit ? */
  715.     /* Enlarge_BoxSize(optr->box); */
  716.     
  717.     optr++;
  718.     ReadLog.objcount++;
  719.   }
  720.  
  721.   ReadLog.totalEnergyLeft = ReadLog.totalEnergy;
  722.   fclose(meshf);
  723.   return(ReadLog.objcount);
  724. }
  725.  
  726. /**********************************************************************/
  727. /* Read in textures from file */
  728. /**********************************************************************/
  729. int Read_Textures(filename, tex)
  730.      char *filename;
  731.      TextureProp **tex;     
  732. {
  733.   if (!(textf = fopen(filename, "r"))) {
  734.     fprintf(stderr,"%s: cannot read texture file %s\n", ProgName, filename);
  735.     exit(1);
  736.   }
  737.   printf("Not implemented yet...sorry no textures\n");
  738.   return 0;
  739. }
  740.  
  741. /**********************************************************************/
  742. /* Print element / receiver list */
  743. /**********************************************************************/
  744. void Print_Elements(elist,elist_size)
  745.      Elist *elist;
  746.      int elist_size;
  747. {
  748.   int i;
  749.   Elist *elptr;
  750.  
  751.   elptr = elist;
  752.   for(i=0;i<elist_size;i++,elptr=elptr->next)
  753.     printf("\tElement %s%d, ff %g, is %sa receiver\n",
  754.        elptr->element->name, elptr->element->id,
  755.        elptr->ff, (elptr->is_receiver == 1 ? "" : "not "));
  756. }
  757.  
  758. /**********************************************************************/
  759. /* Print program options, and statistics */
  760. /**********************************************************************/
  761. void Print_InitialStats(rlog,fp)
  762.      RadParams rlog;
  763.      FILE *fp;
  764. {
  765.   if (rlog.log) {
  766.     fprintf(fp,"\n\t*** Scene statistics ***\n");
  767.     fprintf(fp,"\tTotal objects read: %d\n", rlog.objcount);
  768.     fprintf(fp,"\tTotal meshes read: %d\n", rlog.totmesh);
  769.     fprintf(fp,"\tTotal polygons read: %d\n", rlog.totpoly);
  770.     fprintf(fp,"\tTotal vertices read to octree: %d\n", vtree_size);
  771.     fprintf(fp,"\tTotal textures read: %d\n", rlog.num_textures);
  772.     fprintf(fp,"\n");
  773.     /* if (ReadLog.num_elements > 0) {
  774.        fprintf(fp,"\tTotal elements read: %d\n", rlog.num_elements);
  775.        Print_Elements(rlog.elements, rlog.num_elements);
  776.        fprintf(fp,"\tTotal receivers: %d\n", rlog.num_receivers);
  777.        } */
  778.     fprintf(fp,"\tStopping threshold: %g and iterations: %d\n", rlog.threshold,
  779.        rlog.max_iterations);
  780.     fprintf(fp,"\tIntensity scale for display: %g\n", rlog.intensityScale);
  781.     /* if (Option.ambient)
  782.        fprintf(fp,"\tInitial ambient term: (%g %g %g)\n", 
  783.        rlog.ambient_term.samples[0], rlog.ambient_term.samples[1],
  784.        rlog.ambient_term.samples[2]);
  785.        */
  786.     fprintf(fp,"\tThe worlds radius is: %g\n", rlog.worldSize);
  787.     fprintf(fp,"\t\twith min-point %g,%g,%g\n\t\tand max-point %g,%g,%g\n",
  788.        rlog.worldbox.min.x, rlog.worldbox.min.y, rlog.worldbox.min.z, 
  789.        rlog.worldbox.max.x, rlog.worldbox.max.y, rlog.worldbox.max.z);
  790.     fprintf(fp,"\t\thas a total energy of: %g\n", rlog.totalEnergy);
  791.     fprintf(fp,"\t\tand has a total area of: %g\n", rlog.totalArea);
  792.  
  793.     ff_print_FF_Options(FF_Options);
  794.     if (Option.ff_raytrace == 0) {
  795.       fprintf(fp,"\tUsing hemicube visibility testing, with\n");
  796.       fprintf(fp,"\ttop resolution of %d\n", rlog.hemicubeRes);
  797.     } else {
  798.       if (FF_Options.quadtri_ray) 
  799.     fprintf(fp,"\tUsing Ray-QuadTri intersection test.\n");
  800.       else
  801.     fprintf(fp,"\tUsing Ray-General Polygon intersection test.\n");
  802.       if (Option.grid)
  803.     fprintf(fp,"\tUsing hierarchical bounding volumes\n");
  804.       if (FF_Options.shaft_cull) 
  805.     fprintf(fp,"\tUsing source/receiver shaft culling\n");
  806.       else {
  807.     if (FF_Options.src_rec_cull) 
  808.       fprintf(fp,"\tUsing source and receiver plane culling.\n");
  809.     else
  810.       fprintf(fp,"\tUsing source plane culling.\n");
  811.       }
  812.     }
  813.     fprintf(fp,"\n");
  814.   }
  815. }
  816.  
  817. /**********************************************************************/
  818. /* Read in the scene (s) from file */
  819. /**********************************************************************/
  820. void Read_Scene(s)
  821.      Scene *s;
  822. {
  823.   printf("\n\t*** Reading scene from %s ***\n",Option.meshfilename);
  824.  
  825.   /* Initialize size of the world */
  826.   Init_WorldSize(&ReadLog);
  827.  
  828.   /* Create vertex octree */
  829.   /* vtree = VTree_Create(ReadLog); */
  830.  
  831.   /* Read in objects and textures */
  832.   s->num_objects = Read_Objects(Option.meshfilename, &(s->objects));
  833.   /*  s->num_textures = Read_Textures(Option.textfilename, &(s->textures)); */
  834.  
  835.   /* Read in PR view */
  836.   printf("\n\t*** Reading view from %s ***\n", Option.viewfilename);
  837.   Read_View(Option.viewfilename,&(ReadLog.displayView));
  838.  
  839.   /* Calculate minimum  world size */
  840.   BoxWorld(&ReadLog);
  841.  
  842.   /* Set minimum element area */
  843.   FF_Options.min_element_area = (MIN_ELEMENT_PERC * ReadLog.totalArea / 
  844.                  (double) ReadLog.totpoly);
  845. }
  846.  
  847. /**********************************************************************/
  848. /* Read in a view */
  849. /**********************************************************************/
  850. void Read_View(filename,c)
  851.      char *filename;
  852.      Camera *c;
  853. {
  854.   float t[3];
  855.   int t1, t2;
  856.  
  857.   if (!(viewf = fopen(filename, "r"))) {
  858.     fprintf(stderr,"\t%s: cannot read view file %s\n", ProgName, filename);
  859.     fprintf(stderr,"\tSetting to default viewing parameters\n");
  860.     c->lookfrom.x = ReadLog.worldbox.max.x - 2.*ENLARGE_WORLD;
  861.     c->lookfrom.y = ReadLog.worldbox.max.y - 2.*ENLARGE_WORLD;
  862.     c->lookfrom.z = ReadLog.worldbox.max.z - 2.*ENLARGE_WORLD;
  863.     c->lookat.x = (ReadLog.worldbox.max.x - ReadLog.worldbox.min.x ) / 2.0;
  864.     c->lookat.y = (ReadLog.worldbox.max.y - ReadLog.worldbox.min.y ) / 2.0;
  865.     c->lookat.z = (ReadLog.worldbox.max.z - ReadLog.worldbox.min.z ) / 2.0;
  866.     c->lookup.x = 0.;    c->lookup.y = 1.;       c->lookup.z = 0.;
  867.     c->fovx = 60;   c->fovy = 60;
  868.     c->near = 0.001; c->far = ReadLog.worldSize;
  869.     c->xRes = 256; c->yRes = 256;
  870.     c->bank = 0.0;
  871.  
  872.   } else {
  873.     fscanf(viewf,"Camera {\n");
  874.  
  875.     fscanf(viewf,"lookfrom %g %g %g\n", &t[0], &t[1], &t[2]);
  876.     c->lookfrom.x = t[0];
  877.     c->lookfrom.y = t[1];
  878.     c->lookfrom.z = t[2];
  879.     
  880.     fscanf(viewf,"lookat %g %g %g\n", &t[0], &t[1], &t[2]);
  881.     c->lookat.x = t[0];
  882.     c->lookat.y = t[1];
  883.     c->lookat.z = t[2];
  884.     
  885.     fscanf(viewf,"lookup %g %g %g\n", &t[0], &t[1], &t[2]);
  886.     c->lookup.x = t[0];
  887.     c->lookup.y = t[1];
  888.     c->lookup.z = t[2];
  889.     
  890.     fscanf(viewf,"fovx %d fovy %d near %g far %g\n", &t1, &t2, &t[0], &t[1]);
  891.     c->fovx = t1;   c->fovy = t2;
  892.     c->near = t[0]; c->far = t[1];
  893.     fscanf(viewf,"xRes %d yRes %d\n", &t1, &t2);
  894.     c->xRes = t1; c->yRes = t2;
  895.     fscanf(viewf,"bank %g\n", &t[0]);
  896.     c->bank = t[0];
  897.     fscanf(viewf,"}");
  898.   }
  899.  
  900.   /* Allocate buffer for display purposes */
  901.   c->buffer = (unsigned  long *)
  902.     malloc(ReadLog.displayView.xRes * ReadLog.displayView.yRes *
  903.        sizeof(unsigned long));
  904. }
  905.  
  906. extern int p_count;
  907. /**********************************************************************/
  908. /* Main program... */
  909. /**********************************************************************/
  910. void main(argc, argv)
  911.      int argc;
  912.      char *argv[];
  913. {
  914.   int temp;
  915.   float prep_start, prep_end;
  916.   float tot_start, tot_end;
  917.   char *env_var = "                                                  ";
  918.  
  919.   /* Set up options */
  920.   SetOptions(argc, argv);
  921.   Init_Time();
  922.  
  923.   /* Open table log */
  924.   if ((env_var = getenv("PR_run")) != NULL) {
  925.     Option.tablelogstr = env_var;  
  926.     Option.tablelog = TRUE;
  927.     LogRlog(1,Option.meshfilename,Option.tablelogstr);
  928.   } else 
  929.     Option.tablelog = FALSE;
  930.  
  931.   /* Read the scene in */
  932.   temp = Option.debug; Option.debug = 0;  
  933.  
  934.   if (Option.statistics)
  935.     prep_start = Cpu_Time(&tstats.utime, &tstats.stime);
  936.  
  937.   Read_Scene(&RadScene);
  938.  
  939.   if (Option.statistics) {
  940.     prep_end = Cpu_Time(&tstats.utime, &tstats.stime);
  941.     tstats.prep_Model = (prep_end - prep_start);
  942.   }
  943.  
  944.   if (Option.statistics)
  945.     if (Option.device == PRINT) Print_InitialStats(ReadLog,stdout);
  946.     else Print_InitialStats(ReadLog,Option.StatFile);
  947.   if (Option.print_scene) print_Scene(&RadScene,Option.InLogFilename);
  948.   Option.debug = temp;
  949.  
  950.   /* Build hierarchical bounding volume tree for scene */
  951.   if (Option.grid) { 
  952.  
  953.     /* Build object HBV */
  954.     prep_start = Cpu_Time(&tstats.utime, &tstats.stime);
  955.  
  956.     BVH_Create_Hierarchy(&RadScene, &Scene_BVH);
  957.  
  958.     prep_end = Cpu_Time(&tstats.utime, &tstats.stime);
  959.     tstats.prep_oHBV = (prep_end - prep_start);
  960.     tstats.tot_time += tstats.prep_oHBV;
  961.  
  962.     prep_start = Cpu_Time(&tstats.utime, &tstats.stime);
  963.     
  964.     /* Build polygon HBV */
  965.     BVH_Create_PHierarchy(&Scene_BVH);
  966.     /* printf("\t%d Polygons added to tree.\n", p_count); */
  967.     Enlarge_Root();
  968.  
  969.     prep_end = Cpu_Time(&tstats.utime, &tstats.stime);
  970.     tstats.prep_pHBV = (prep_end - prep_start);
  971.     tstats.tot_time += tstats.prep_pHBV;
  972.  
  973.     if (Option.debug) {
  974.       printf("\t*** Hierarchical BV tree ***\n");
  975.       temp = Option.debug;
  976.       Option.debug = 0;
  977.       BVH_PrintBox(&Scene_BVH);
  978.       BVH_PrintHier(&Scene_BVH);
  979.       printf("\n");
  980.       Option.debug = temp;
  981.     }
  982.   }
  983.  
  984.   /* Run radiosity on the scene */
  985.   Init_Rad(&RadScene);
  986.   Do_Rad();
  987.  
  988.   /* Perform cleanup */
  989.   /* CleanUp_Rad(); */
  990.   if (Option.statistics)
  991.     if (Option.device == FILES)
  992.       LogStats(0);
  993.  
  994.   /* Log scene with radiosity calculated */
  995.   if (Option.print_scene) print_Scene(&RadScene, Option.OutLogFilename);
  996.  
  997.   /* Output polygonal scene to file */
  998.   if (Option.write_result) {
  999.     /*  Create_Initial_ReceiverList(&RadScene); */
  1000.     Write_Rad(ReadLog, Option.OutSceneFilename,-1);
  1001.   }
  1002.  
  1003.   /* Close table log */
  1004.   if (Option.tablelog == TRUE)
  1005.     LogRlog(0,"","");
  1006. }
  1007.